home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / Libraries / DCLAP 6d / dclap6d / DBio / DSeqAsmDoc.cpp < prev    next >
Text File  |  1996-07-05  |  20KB  |  821 lines
  1. // DSeqAsmDoc.cp
  2.  
  3. #define POPBASECALL
  4.  
  5. #include "DSeqAsmDoc.h"
  6.  
  7. #include <ncbi.h>
  8. #include <dgg.h>
  9. #include <Dvibrant.h>
  10. #include <DApplication.h>
  11. #include <DClipboard.h>
  12. #include <DControl.h>
  13. #include <DWindow.h>
  14. #include <DRichViewNu.h>
  15. #include <DTableView.h>
  16. #include <DViewCentral.h>
  17. #include <DTask.h>
  18. #include <DTracker.h>
  19. #include <DMenu.h>
  20. #include <DUtil.h>
  21. #include <DFindDlog.h>
  22. #include "DRichHandler.h"
  23. #include "DSeqFile.h"
  24. #include "DSeqEd.h"
  25. #include "DSeqMail.h"
  26. #include "DSeqCmds.h"
  27. #include "DSeqChildApp.h"
  28. #include "DSeqPrint.h"
  29. #include "DSeqPict.h"
  30. #include "DSeqViews.h"
  31.  
  32. #include "DSeqAsmView.h"
  33. #include "DAsmSequence.h"
  34.  
  35. #ifdef POPBASECALL
  36. #include "DBaseCallPop.h"
  37. #endif
  38.  
  39. static char gDefSeqNameStore[128];
  40. Boolean  DSeqAsmDoc::fgTestAutoseqFile = false; // turn on/off seq-test for OpenDocument()
  41.  
  42.  
  43. enum { kModeAsmPopup = 3310, kColorAsmPopup, kBaseOnTrace };
  44.  
  45.  
  46. class DAsmModePopup : public DPopupList
  47. {
  48. public:
  49.     DAsmModePopup(long id, DView* superior);
  50.     virtual short GetValue() { return DAlnView::kModeSlide + DPopupList::GetValue() - 1; }
  51. };
  52.  
  53. DAsmModePopup::DAsmModePopup(long id, DView* superior) :
  54.             DPopupList(id,superior,true)
  55. {
  56.     AddItem( "Slide bases");
  57.     AddItem( "Edit bases");
  58.     AddItem( "Bases + Traces");
  59.     AddItem( "A Bases + Trace");
  60.     AddItem( "C Bases + Trace");
  61.     AddItem( "G Bases + Trace");
  62.     AddItem( "T Bases + Trace");
  63.     this->SetValue(3);
  64. }
  65.  
  66.  
  67. class DAsmColorPopup : public DPopupList
  68. {
  69. public:
  70.     DAsmColorPopup(long id, DView* superior, short defaultvalue);
  71.     virtual short GetValue() { return DAlnView::kBaseBlack + DPopupList::GetValue() - 1; }
  72. };
  73.  
  74. DAsmColorPopup::DAsmColorPopup(long id, DView* superior, short defaultvalue) :
  75.             DPopupList(id,superior,true)
  76. {
  77.     AddItem( "Black");
  78.     AddItem( "Color");
  79.     this->SetValue(2); // (defaultvalue + 1 - DAlnView::kBaseBlack);
  80. }
  81.  
  82. // this dups in DSeqDoc
  83. class DSeqFormatPopup1 : public DPopupList
  84. {
  85. public:
  86.     DSeqFormatPopup1(long id, DView* superior, short defaultFormat);
  87.     virtual short GetValue() { return DSeqFile::kMinFormat + DPopupList::GetValue() - 1; }
  88. };
  89.  
  90. DSeqFormatPopup1::DSeqFormatPopup1(long id, DView* superior, short defaultFormat) :
  91.             DPopupList(id,superior,true)
  92. {
  93.     for (short i= DSeqFile::kMinFormat; i<=DSeqFile::kMaxFormat; i++) 
  94.         this->AddItem( (char*)DSeqFile::FormatName(i));
  95.     this->SetValue(defaultFormat);
  96. }
  97.  
  98.  
  99.  
  100. #ifdef notnowPOPBASECALL
  101.  
  102. enum { kBaseCallPopup = 4987 };
  103.  
  104. class DBaseCallPop1 : public DPopupList {
  105. public:
  106.     Boolean fVisible;
  107.     DAsmView* fAsmView;
  108.     
  109.     DBaseCallPop1(long id, DView* itsSuperior);
  110.     virtual short GetValue() { return /*basemode + */ DPopupList::GetValue() - 1; }
  111.     virtual Boolean IsMyAction(DTaskMaster* action);
  112. };
  113.  
  114. DBaseCallPop1* gBaseCallPop1 = NULL; // convert to field in fAsmDoc
  115.  
  116.  
  117. DBaseCallPop1::DBaseCallPop1(long id, DView* itsSuperior):
  118.         DPopupList(id, itsSuperior), 
  119.         fVisible(false), fAsmView(NULL) 
  120. {
  121.     //fAsmView= itsSuperior;
  122.     AddItem("clear bases");
  123.     AddItem("set A");
  124.     AddItem("set C");
  125.     AddItem("set G");
  126.     AddItem("set T");
  127.     // ?? stats display at position, other functions at trace position?
  128. }
  129.  
  130.  
  131. Boolean DBaseCallPop1::IsMyAction(DTaskMaster* action) 
  132. {
  133.     switch(action->Id()) {
  134.     
  135.      case kBaseCallPopup: {
  136.         Message(MSG_OK,"DBaseCallPop1::action not ready.");
  137.         short mode= this->GetValue();  
  138.         //fAsmView->SetViewMode( mode);
  139.         switch (mode) {
  140.             case 0: break;
  141.             case 1: break; // set a
  142.             case 2: break; // set c
  143.             case 3: break;
  144.             case 4: break;
  145.             }
  146.       return true;
  147.         }
  148.         
  149. #if 0
  150.         case DApplication::kFind:
  151.         case DApplication::kFindAgain:
  152.             return gApplication->DoMenuTask(action->Id(), NULL);
  153.         case DSeqDoc::cFindORF:
  154.             return fAlnView->fDoc->DoMenuTask( action->Id(), NULL);
  155. #endif
  156.         default:
  157.             return DPopupList::IsMyAction(action);
  158.         }
  159. }
  160.  
  161. #endif
  162.  
  163.  
  164.  
  165.  
  166.  
  167. //class DSeqAsmDoc
  168.  
  169.  
  170. DSeqAsmDoc::DSeqAsmDoc( long id, DSeqList* itsSeqList, char* name) :
  171.         DSeqDoc( id, itsSeqList, name),
  172.         fAsmSeq(NULL), fAutoseqFilesRead(0) , fNtrace(0), fHaveAsmseq(false)
  173. { 
  174. }
  175.  
  176. DSeqAsmDoc::~DSeqAsmDoc()
  177. {
  178. }
  179.  
  180. void DSeqAsmDoc::FreeData()
  181. {
  182.     DSeqDoc::FreeData();
  183. }
  184.  
  185.  
  186. // static
  187. Boolean DSeqAsmDoc::IsAutoseqFile(DFile* aFile)
  188. {
  189.     if (aFile && aFile->Exists()) {
  190.         if (fgTestAutoseqFile) return true;
  191.         aFile->OpenFile("r");
  192.         Boolean isautoseq= true;
  193.         short  nline= 0;
  194.         while (!aFile->Eof() && nline<4 && isautoseq) {
  195.             char  buf[256];
  196.             aFile->ReadLine( buf, sizeof(buf)); nline++;
  197.             switch (nline) {
  198.                 case 1: 
  199.                     if (StrNCmp(buf, "filename:", 9) != 0) isautoseq= false;
  200.                     break;
  201.                 case 2: 
  202.                     if (StrNCmp(buf, "native format:", 14) != 0) isautoseq= false;
  203.                     break;
  204.                 case 3: 
  205.                     if (StrNCmp(buf, "strand:", 7) != 0) isautoseq= false;
  206.                     break;
  207.                 case 4: 
  208.                     if (StrNCmp(buf, "total size:", 11) != 0) isautoseq= false;
  209.                     break;
  210.                 }
  211.             }
  212.         aFile->Close();
  213.         return isautoseq;
  214.         }
  215.     else {
  216.         return false;
  217.         }
  218. }
  219.  
  220.  
  221. // static
  222. void DSeqAsmDoc::NewSeqAsmDoc()
  223. {
  224.     DSeqAsmDoc* newdoc= new DSeqAsmDoc( DSeqAsmDoc::kSeqAsmdoc, NULL, (char*)DFileManager::kUntitled);
  225.     newdoc->Open();
  226.     //newdoc->EditSeqs(); //?? make it real obvious to beginners?
  227. }
  228.  
  229. // static
  230. void DSeqAsmDoc::GetSeqAsmGlobals()
  231. {
  232. }
  233.  
  234. // static
  235. void DSeqAsmDoc::SaveSeqAsmGlobals()
  236. {
  237. }
  238.  
  239.  
  240. void DSeqAsmDoc::MakeGlobalsCurrent()
  241. {
  242.     DSeqDoc::MakeGlobalsCurrent();
  243. }
  244.  
  245. void DSeqAsmDoc::Close()
  246. {
  247.     DSeqDoc::Close();
  248. }
  249.  
  250.  
  251. void DSeqAsmDoc::Open(DFile* aFile)
  252. {
  253.     if (DSeqAsmDoc::fgTestAutoseqFile) 
  254.         DSeqDoc::Open(aFile);
  255.     else {
  256.         fAutoseqFilesRead= 0; // always in this case, but don't know when coming from autoseq
  257.  
  258.         short gotTrace= 0;
  259.         Boolean isempty= (fSeqList->GetSize() < 1);
  260.         aFile->fType="autoseq/tfs";  
  261.         
  262.         //DSeqDoc::Open(aFile);
  263.         if ( !ReadFrom( aFile, true) ) {
  264.                 if (isempty) this->suicide();
  265.                 return;
  266.                 }
  267.  
  268.         // user selected autoseq.tfs file .. now look for .A, .C, .. files
  269.         char *fname, buf[512];
  270.         StrNCpy( buf, aFile->GetName(), sizeof(buf));
  271.         DFileManager::ReplaceSuffix( buf, sizeof(buf), ".A");
  272.         DFile bFile( buf);
  273.         if (bFile.Exists()) {
  274.             bFile.fType= "autoseq/atrace";  
  275.             //DSeqDoc::Open(&bFile);
  276.             if ( ReadFrom( &bFile, true) ) gotTrace++;
  277.             }
  278.         
  279.         DFileManager::ReplaceSuffix( buf, sizeof(buf), ".C");
  280.         bFile.SetName( buf);
  281.         if (bFile.Exists()) {
  282.             bFile.fType= "autoseq/ctrace";  
  283.             //DSeqDoc::Open(&bFile);
  284.             if ( ReadFrom( &bFile, true) ) gotTrace++;
  285.             }
  286.  
  287.         DFileManager::ReplaceSuffix( buf, sizeof(buf), ".G");
  288.         bFile.SetName( buf);
  289.         if (bFile.Exists()) {
  290.             bFile.fType= "autoseq/gtrace";  
  291.             //DSeqDoc::Open(&bFile);
  292.             if ( ReadFrom( &bFile, true) ) gotTrace++;
  293.             }
  294.  
  295.         DFileManager::ReplaceSuffix( buf, sizeof(buf), ".T");
  296.         bFile.SetName( buf);
  297.         if (bFile.Exists()) {
  298.             bFile.fType= "autoseq/ttrace";  
  299.             //DSeqDoc::Open(&bFile);
  300.             if ( ReadFrom( &bFile, true) ) gotTrace++;
  301.             }
  302.  
  303.         if (gotTrace) {
  304.             if (isempty) {
  305.                 this->SetTitle((char*)aFile->GetShortname());
  306.                 this->SetFilename((char*)aFile->GetName());
  307.                 }
  308.             this->Open();
  309.             }
  310.         else if (isempty) this->suicide();
  311.         } 
  312. }
  313.  
  314.  
  315. void DSeqAsmDoc::Revert()
  316. {
  317.     DSeqDoc::Revert();
  318. }
  319.  
  320. void DSeqAsmDoc::AddAlnIndex(DView* super, short width, short height)
  321. {
  322.     fAlnIndex= new DAlnIndex(0, super, this, fSeqList, width, height); 
  323. }
  324.  
  325. void DSeqAsmDoc::AddAlnView(DView* super, short width, short height)
  326. {
  327.     if (fHaveAsmseq)
  328.         fAlnView= new DAsmView(0, super, this, fSeqList, width, height); 
  329.     else
  330.         fAlnView= new DAlnView(0, super, this, fSeqList, width, height); 
  331. }
  332.  
  333. void DSeqAsmDoc::AddModePopup(DView* super)
  334. {
  335.     fModePop= new DAsmModePopup(kModeAsmPopup, super);
  336. }
  337.  
  338.  
  339. void DSeqAsmDoc::AddTopViews(DView* super)
  340. {
  341.     DPrompt* pr;
  342.  
  343.     pr= new DPrompt(0,super,"Color:",0, 0, Nlm_programFont);
  344.     super->NextSubviewToRight();
  345.     fColorPop= new DAsmColorPopup(kColorPopup,super,fgUseColor); //kColorAsmPopup
  346.     fUseColor= fgUseColor; // not used??
  347.     super->NextSubviewToRight();
  348.  
  349.     pr= new DPrompt(0,super," View:",0, 0, Nlm_programFont);
  350.     super->NextSubviewToRight();
  351.     this->AddModePopup(super); 
  352.     fLockCheck= NULL;
  353.  
  354.     super->NextSubviewToRight();
  355.     pr= new DPrompt(0,super,"  File format:",0, 0, Nlm_programFont);
  356.  
  357.     DCluster* metergrp= new DCluster( 0, this, 0, 0, true);   // was 0,0 for w,h
  358.     pr= new DPrompt(0,metergrp,"Point#",0, 0, Nlm_programFont);
  359.     metergrp->NextSubviewToRight();
  360.     fSeqMeter= new DPrompt(0,metergrp,"0000000",0,0,Nlm_programFont,justright); //60,14
  361.  
  362.     super->NextSubviewToRight();
  363.     fFormatPop= new DSeqFormatPopup1(0,super,fInFormat);
  364.     
  365.     super->NextSubviewBelowLeft();
  366. }
  367.  
  368.  
  369. void DSeqAsmDoc::AddViews()
  370. {
  371.     Boolean needviews= (!fAlnView || !fAlnIndex || !fAlnHIndex || !fAlnITitle);
  372.     if (needviews) {
  373.         new DPrompt(0,this,"  * PRELIMINARY Sequence Assembly *  ",0, 0, Nlm_systemFont);
  374.  
  375.         if (fHaveAsmseq) {
  376.             DView* super= this;
  377.             super->NextSubviewToRight();
  378.             DCheckBox* ck= new DCheckBox(kBaseOnTrace,super, "");
  379.             ck->SetStatus(true); // default behavior, no sticky pref yet
  380.             super->NextSubviewToRight();
  381.             (void) new DPrompt(0, super, "Bases on trace",0, 0, Nlm_programFont);
  382.             }
  383.         this->NextSubviewBelowLeft();
  384.         }
  385.         
  386.     DSeqDoc::AddViews();
  387. }
  388.  
  389.  
  390. void DSeqAsmDoc::Open()
  391. {
  392. #if 0    
  393.     DSeqDoc::Open();
  394. #else
  395.     Boolean selectone= false;
  396.     if (!fSeqList) fSeqList= new DSeqList();
  397.     if (fSeqList->GetSize() == 0) {
  398.         fSeqList->AddNewSeq();    // install 1 blank seq for new doc
  399.         selectone= true;
  400.         }
  401.     
  402.     AddViews();
  403.     fSaveHandler= this;  
  404.     fPrintHandler= this; 
  405.  
  406.     this->Select(); // for motif
  407.     this->CalcWindowSize();
  408.     fAlnView->GetReadyToShow(); // do before others ...
  409.     if (fAlnIndex) fAlnIndex->GetReadyToShow();
  410.     fAlnITitle->GetReadyToShow();
  411.  
  412.     fAlnView->SetViewColor(fgUseColor);
  413.     fAlnView->SetViewMode(fgViewMode);
  414.     if (selectone && fAlnIndex) fAlnIndex->SelectCells(0,0);
  415.     fSeqMeter->Show();  
  416.     
  417.     DWindow::Open();
  418. #endif
  419. }
  420.  
  421.  
  422. void DSeqAsmDoc::Activate()
  423. {
  424.     DSeqDoc::Activate();
  425. }
  426.  
  427. void DSeqAsmDoc::Deactivate()
  428. {
  429.     DSeqDoc::Deactivate();
  430. }
  431.  
  432. void DSeqAsmDoc::Print()
  433. {
  434.     DSeqDoc::Print();
  435. }
  436.  
  437. Boolean DSeqAsmDoc::IsMyTask(DTask* theTask) 
  438. {
  439.     return DSeqDoc::IsMyTask(theTask);
  440. }
  441.  
  442. void DSeqAsmDoc::ProcessTask(DTask* theTask) 
  443. {
  444.     if (theTask->fNumber == -87654) {
  445.  
  446.         }
  447.     else {
  448.         DSeqDoc::ProcessTask(theTask);
  449.         }
  450. }
  451.  
  452.  
  453. void DSeqAsmDoc::SortView(DSeqList::Sorts sortorder)
  454. {
  455.     //DSeqDoc::SortView(sortorder);
  456. }
  457.  
  458.  
  459. void DSeqAsmDoc::AddSeqToList(DSequence* item)
  460. {
  461.     DSeqDoc::AddSeqToList(item);
  462. }    
  463.  
  464.  
  465.  
  466. void DSeqAsmDoc::AddNewSeqToList()
  467. {
  468.     DSeqDoc::AddNewSeqToList();
  469. }
  470.  
  471.   
  472. void DSeqAsmDoc::GetSelection( long selectFlags, DSeqList*& aSeqList, 
  473.                             long& start, long& nbases)
  474. {
  475.     DSeqDoc::GetSelection( selectFlags, aSeqList, start, nbases);
  476. }
  477.             
  478.  
  479. short DSeqAsmDoc::SelectionToFile(Boolean AllatNoSelection, char* aFileName, 
  480.             short seqFormat)  
  481. {
  482.     return DSeqDoc::SelectionToFile( AllatNoSelection, aFileName, seqFormat);
  483. }
  484.  
  485.  
  486. void DSeqAsmDoc::WriteTo(DFile* aFile)  
  487. {
  488. #if 0
  489.     DSeqDoc::WriteTo( aFile);
  490. #else    
  491.     long i, n = fSeqList->GetSize();
  492.     for (i=0; i<n; i++) {
  493.         char * name, newname[512], backname[512];
  494.         fAsmSeq= (DAsmSequence*) fSeqList->SeqAt(i);
  495.         Boolean dotrace= fAsmSeq->ShowTrace() && (fAsmSeq->Kind() == DAsmSequence::kAutoseq);
  496.         if (!dotrace)  
  497.             ; //DSeqDoc::WriteTo( aFile); << not for single sequences...
  498.         else {
  499.             fAsmSeq->TraceToBases();
  500.             name = (char*)fAsmSeq->TracefileName();
  501.             //if (!name) name= "myseq.tfs";
  502.             DFile fromFile(name);
  503.             if (i>0) {
  504.                 sprintf( newname, "%s.new", name);
  505.                 sprintf(backname, "%s.old", name);
  506.                 aFile= new DFile(newname);
  507.                 }
  508.             ReadTraceStats( &fromFile, true, aFile);  
  509.             if (i>0) {
  510.                 DFileManager::Rename( name, backname);
  511.                 DFileManager::Rename( newname, name);
  512.                 }
  513.             }
  514.         }
  515.     this->NotDirty();  
  516. #endif
  517. }
  518.  
  519.  
  520.  
  521.  
  522. void DSeqAsmDoc::ReadTrace(DFile* aFile, short tracenum)     
  523. {
  524.     char   * cp, buf[512];
  525.     TraceBase  tb, * tbuf = NULL;  
  526.     long   np= 0, maxp = 0;
  527.     Boolean traceokay;
  528.     short ht, maxht = 0;
  529.     
  530.     aFile->Open("r"); fAutoseqFilesRead++;
  531.     tbuf= fAsmSeq->Trace();
  532.     np= 0; // NO: fAsmSeq->NumPoints();  
  533.     maxp= fAsmSeq->MaxPoints();
  534.     traceokay= (tracenum>=TraceBase::tA && tracenum<=TraceBase::tT); 
  535.     while (!aFile->Eof()) {
  536.         aFile->ReadLine( buf, sizeof(buf));
  537.         cp= buf; 
  538.         ht= atoi(cp); maxht= Max( maxht, ht);
  539.         
  540.         if (np >= maxp) {    
  541.             if (fNtrace && !maxp)maxp= fNtrace+1;// read maxp from ReadTraceStats()
  542.             else maxp += 1000;
  543. #if 1
  544.             fAsmSeq->UpdateTrace( tbuf, np, maxp);
  545. #else
  546.             TraceBase* tmpb= new TraceBase[ maxp];
  547.             if (tbuf) {
  548.                 MemCpy( tmpb, tbuf, np * sizeof(TraceBase));
  549.                 delete tbuf;
  550.                 }
  551.             //fAsmSeq->FreeTrace();
  552.             tbuf= tmpb;
  553. #endif
  554.             if (!tbuf) traceokay= false;
  555.             }
  556.         if (traceokay) {
  557.             tb= tbuf[np];
  558.             tb.tr[tracenum]= ht;
  559.             tbuf[np++]= tb;
  560.             }
  561.         }
  562.         
  563.     if (tbuf && maxp) {
  564. #if 1
  565.         fAsmSeq->UpdateTrace( tbuf, np, maxp); 
  566. #else
  567.         fAsmSeq->SetTrace( tbuf, np, maxp, false); 
  568. #endif
  569.         fAsmSeq->SetMaxHeight( tracenum, maxht);
  570.         }
  571. }
  572.  
  573.          
  574. void DSeqAsmDoc::ReadTraceStats(DFile* aFile, Boolean rewrite, DFile* toFile)     
  575. {
  576. #if 0
  577. // autoseq/tfs format
  578. // various doc and values at top...
  579. total size:    5079
  580. window:        [0,5078]  (5079 points)
  581. min/max/mean:    0/255/29  (within window)
  582. sequence len:    454
  583. ///
  584. peaks picked:    495
  585. //#    X    ht    ctr    left   right  width      P(H) P(D|NULL)    P(D|H)    P(H|D)
  586. 1    G    42      0     0.0     2.6    2.6  1.00e+00  1.97e-03  8.92e-01  9.98e-01
  587. 2    T    39      0     0.0     4.3    4.3  1.00e+00  6.58e-05  3.67e+04  1.00e+00
  588. 3    A    66     15     8.6    18.7   10.1  1.00e+00  1.41e-04  2.13e+02  1.00e+00
  589. 4    G   128     15    10.4    21.0   10.6  1.00e+00  7.01e-12  1.84e+16  1.00e+00
  590. 5    T    26     17    12.2    22.0    9.8  1.00e+00  2.20e-03  2.72e+01  1.00e+00
  591. 6    C    36     25    19.9    37.0   17.1  1.00e+00  5.36e-03  1.53e-01  9.66e-01
  592. 7    G    44     28    21.0    31.8   10.8  1.00e+00  1.57e-03  1.41e+00  9.99e-01
  593. 8    T    37     28    22.0    33.8   11.8  1.00e+00  1.24e-04  1.02e+04  1.00e+00
  594. 9    A    80     32    28.1    35.6    7.6  1.00e+00  1.42e-05  1.99e+04  1.00e+00
  595. 10   C    24     52    48.6    55.8    7.2  1.00e+00  1.01e-02  3.84e-02  7.92e-01
  596. ... to 495
  597. #endif
  598.  
  599.     char  base, buf[512], buf2[128];
  600.     int        num, ht, ctr, npeaks = 0, npoints = 0; // int for sscanf(%d)
  601.     float        left, right, width;
  602.     float        ph, pd, phd, pdh;
  603.     Boolean    incolumns = false, gotpeaks = false;
  604.     char    * bseq = NULL;
  605.     short    * cseq = NULL;
  606.     TraceBase * tbuf = NULL;
  607.     long        atpt, num1, ns= 0, maxs= 0;
  608.     
  609.     aFile->Open("r"); 
  610.     fAutoseqFilesRead++;
  611.     if (rewrite) {
  612.         if (!toFile) return;
  613.         toFile->Open("w");
  614.         atpt= num1 = 0;
  615.         tbuf= fAsmSeq->Trace();
  616.         }
  617.         
  618.     while (!aFile->Eof()) {
  619.         MemSet( buf, 0, sizeof(buf));
  620.         aFile->ReadLine( buf, sizeof(buf));
  621.         if (*buf < ' ') ;
  622.         else if (incolumns) {
  623.             const char* scanform  = "%d %c %d %d %f %f %f %e %e %e %e";
  624.             const char* printform = 
  625.                 "%-4d %c %5d %6d %7.1f %7.1f %6.1f %10.2e %10.2e %10.2e %10.2e\n";
  626.             num= ht= ctr= 0;
  627.             //MemSet( buf2, 0, sizeof(buf2));
  628.             sscanf( buf, scanform,
  629.                          &num, &base, &ht, &ctr, &left, &right, &width, &ph, &pd, &pdh, &phd);
  630.             // num should be in [1..npeaks]
  631.     
  632.             if (rewrite) {
  633.                 num1++; // need to replace num w/ num1 in buf !
  634.                 sprintf( buf, printform,
  635.                                   num1, base, ht, ctr, left, right, width, ph, pd, pdh, phd);
  636.                 toFile->WriteLine( buf);
  637.                 *buf= 0;
  638.                                   
  639.                         // added points
  640.                 while (atpt < ctr) {
  641.                     TraceBase tr= tbuf[atpt];
  642.                     if (tr.base) {
  643.                         long  ht = 0;
  644.                         //char *rest= " 1.0       0.0       0.0       0.0     ";
  645.                         switch (tr.base) {
  646.                             case 'A': ht= tr.tr[0]; break;
  647.                             case 'C': ht= tr.tr[1]; break;
  648.                             case 'G': ht= tr.tr[2]; break;
  649.                             case 'T': ht= tr.tr[3]; break;
  650.                             }
  651.                         num1++;
  652.                         MemSet( buf2, 0, sizeof(buf2));
  653.                         sprintf( buf2, printform,
  654.                                      num1, tr.base, ht, atpt, 
  655.                                      (float)atpt-1, (float)atpt+1, 3.0, 1.0, 0.0, 0.0, 1.0);
  656.                         toFile->WriteLine( buf2);
  657.                         }
  658.                     atpt++;
  659.                     }
  660.                         // deleted points -- tbuf[ctr].base == null !!
  661.                 if (atpt > ctr) {
  662.                         // !? what of extra old points we had to shift up?
  663.                     ctr= atpt; //??
  664.                     }
  665.  
  666.                 if (!tbuf[ctr].base) *buf= 0;
  667.                 else atpt++; //??
  668.                 }
  669.             else {
  670.                 if (ns >= maxs) {
  671.                     if (maxs == 0) maxs = 1+npeaks;
  672.                     else maxs += 1000;
  673.                     if (bseq) bseq= (char*) MemMore(bseq, maxs * sizeof(char));
  674.                     else bseq= (char*) MemNew( maxs * sizeof(char));
  675.                     if (cseq) cseq= (short*) MemMore(cseq, maxs * sizeof(short));
  676.                     else cseq= (short*) MemNew( maxs * sizeof(short));
  677.                     }
  678.                 bseq[ns]= base;
  679.                 cseq[ns]= ctr;
  680.                 }
  681.             ns++;
  682.             if (ns >= npeaks) incolumns= false; // !?
  683.             }
  684.         else if (gotpeaks) {
  685.             if (*buf == '#') incolumns= true;
  686.             }
  687.         else if (StrNICmp(buf,"peaks picked:",13) == 0) {
  688.             sscanf( buf, "peaks picked: %d", &npeaks);
  689.             gotpeaks= true;
  690.             if (rewrite) sprintf( buf, "peaks picked: %d\n", fAsmSeq->LengthF());
  691.             }    
  692.         else if (StrNICmp(buf,"total size:",11) == 0) {
  693.             npoints= 0;
  694.             sscanf( buf, "total size: %d", &npoints);
  695.             fNtrace= npoints;
  696.             }    
  697.             
  698.         if (rewrite && *buf) toFile->WriteLine( buf);
  699.         }
  700.         
  701.     if (rewrite) toFile->Close();
  702.     else if (ns && bseq && cseq) {
  703.         bseq[ns]= 0;
  704.         cseq[ns]= 0;
  705.         fAsmSeq->SetBases( bseq, false); 
  706.         fAsmSeq->SetTrCenter( cseq, ns, false);  // don't need now??
  707.         fAsmSeq->SetPoints( npoints);
  708.         fAsmSeq->SetTracefileName( (char*)aFile->GetName());
  709.         fAsmSeq->SetName( (char*)aFile->GetShortname());
  710.         }
  711. }
  712.  
  713.  
  714.  
  715. Boolean DSeqAsmDoc::ReadFrom(DFile* aFile, Boolean append)    // revise for iostreams
  716. {
  717.     if (!append) FreeData();   
  718.     gDefSeqName= this->GetTitle(gDefSeqNameStore,sizeof(gDefSeqNameStore));
  719.     if (!fSeqList) fSeqList= new DSeqList();
  720.     if (!fAsmSeq) {
  721.         fAsmSeq= new DAsmSequence();
  722.         fSeqList->InsertLast( fAsmSeq);
  723.         }
  724.  
  725.     char* ft= aFile->fType; // fType holds autoseq/type string !?
  726.     if (StrICmp(ft, "autoseq/pseq")==0)  
  727.         ; // fInFormat= DSeqFile::ReadSeqFile(aFile, fSeqList);   << don't need
  728.     else if (StrICmp(ft, "autoseq/tfs")==0)     ReadTraceStats( aFile);  
  729.     else if (StrICmp(ft, "autoseq/atrace")==0)    ReadTrace( aFile, TraceBase::tA);
  730.     else if (StrICmp(ft, "autoseq/ctrace")==0)     ReadTrace( aFile, TraceBase::tC);
  731.     else if (StrICmp(ft, "autoseq/gtrace")==0)    ReadTrace( aFile, TraceBase::tG);
  732.     else if (StrICmp(ft, "autoseq/ttrace")==0)    ReadTrace( aFile, TraceBase::tT);
  733.     else return false;
  734.     
  735.     fHaveAsmseq= true;
  736.     // can we remove this mem leak now?
  737.     // NO: This is too risky -- caller should solve the leak
  738.     // MemFree(aFile->fType); aFile->fType=NULL;
  739.  
  740.     if (fAutoseqFilesRead >= 5) {
  741.         // got all files for fAsmSeq, reset for next autoseq set...
  742.         // set fAsmSeq->Trace().base using TrCenter
  743.         TraceBase * tr = fAsmSeq->Trace();
  744.         short * trc = fAsmSeq->TrCenter();
  745.         long ntr= fAsmSeq->NumPoints();
  746.         for (long i=0; i<fAsmSeq->LengthF(); i++) {
  747.             short ctr= trc[i];
  748.             if (ctr>=0 && ctr<ntr) {
  749.                 while (tr[ctr].base > ' ' && ctr<ntr) ctr++; // can't overlap bases !
  750.                 tr[ctr].base= fAsmSeq->Bases()[i];
  751.                 }
  752.             }
  753.         fAsmSeq= NULL; 
  754.         fAutoseqFilesRead= 0;
  755.         }    
  756.         
  757.     return true;  
  758. }
  759.  
  760.  
  761. void DSeqAsmDoc::OpenSeqedWindow(DSequence* aSeq)
  762. {
  763.     // disallow this, for now... trashes DAsmSequence
  764. }
  765.  
  766.  
  767. void DSeqAsmDoc::MakeSeqPrint(Boolean doREMap)
  768. {
  769.     DSeqDoc::MakeSeqPrint( doREMap);
  770. }
  771.  
  772.  
  773. // static
  774. void DSeqAsmDoc::SetUpMenu(short menuId, DMenu*& aMenu) 
  775. {
  776.     // all done in DSeqDoc::SeqUpMenu() ??
  777. }
  778.  
  779.  
  780. Boolean DSeqAsmDoc::DoMenuTask(long tasknum, DTask* theTask)
  781. {
  782.     return DSeqDoc::DoMenuTask( tasknum, theTask);
  783. }
  784.  
  785.  
  786. Boolean DSeqAsmDoc::IsMyAction(DTaskMaster* action) 
  787. {
  788.     long  menuid= 0, menuitem = action->Id();
  789.  
  790.     if (menuitem == kModeAsmPopup) {
  791.         short mode= fModePop->GetValue();  
  792.         fAlnView->SetViewMode( mode);
  793.       return true;
  794.       }
  795.     else if (fHaveAsmseq && menuitem == kBaseOnTrace) {
  796.         ((DAsmView*)fAlnView)->fBaseOnTrace= ((DView*)action)->GetStatus();
  797.         ((DAsmView*)fAlnView)->Invalidate();
  798.       return true;
  799.         }
  800.         
  801. #ifdef POPBASECALL
  802.     else if (menuitem == kBaseCallPopup) {
  803.         return ((DAsmView*)fAlnView)->fBaseCallPop->IsMyAction( action);
  804.         }
  805. #endif
  806.  
  807. #if 0
  808.     else if (menuitem == kColorAsmPopup) {
  809.         fgUseColor= fColorPop->GetValue();
  810.         fAlnView->SetViewColor( fgUseColor);
  811.       return true;
  812.         }
  813. #endif
  814.     else
  815.         return DSeqDoc::IsMyAction( action);
  816. }
  817.             
  818.  
  819.  
  820.  
  821.